package 笔试.华为笔试.第二题;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

//第二题：输入一组矩形，分别给出宽和高，求这些矩形组成的连续最大面积（最大柱状图面积的变形）。
//这题算法上leetcode有变形，算法倒是不难。比较费事的是输入格式，输入的是 “[1,2,3],[1,2,3]" 这样的一行字符串，
// 第一个数组是宽，第二个数组是高，用c++费了好大劲一个个字符串处理的，这时候特别想念Python的split.
//这题还考了边界处理，包括非法字符，两个数组长度不对等，宽<=0或高<=0的情况。不处理边界只能拿70%，别问我怎么知道的。
public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 0; i < line.length(); i++)
        {
            if (line.charAt(i) == '[' || line.charAt(i) == ']' || line.charAt(i) == ',')
                continue;
            boolean flag = Character.isDigit(line.charAt(i));
            if (!flag)
            {
                System.out.println(0);
                return;
            }
            int temp = Integer.parseInt(String.valueOf(line.charAt(i)));
            if (temp < 1 || temp > 100)
            {
                System.out.println(0);
                return;
            }
            list.add(temp);
        }
        if (list.size() % 2 == 1)//长度不等
        {
            System.out.println(0);
            return;
        }
        int[] height = new int[list.size() / 2];
        int[] width = new int[list.size() / 2];
        int index = 0;

        for (int i = 0; i < width.length; i++)
        {
            width[i] = list.get(index++);
        }
        for (int i = 0; i < height.length; i++)
        {
            height[i] = list.get(index++);
        }
        long[] dp = new long[list.size() / 2];
        //暴力法，直接固定高度，向左右扩散。遇到小的就到达了边界，最后得到了某一固定高度下的总长度
        for (int i = 0; i < dp.length; i++)
        {
            long temp = width[i];//宽度，可以增长
            for (int j = i - 1; j >= 0; j--)
            {
                if (height[j] >= height[i])
                    temp += width[j];
                else
                    break;
            }
            for (int j = i + 1; j < dp.length; j++)
            {
                if (height[j] >= height[i])
                    temp += width[j];
                else
                    break;
            }
            dp[i] = height[i] * temp;
        }
        long max = dp[0];
        for (int i = 1; i < dp.length; i++)
        {
            if (dp[i] > max)
                max = dp[i];
        }
        System.out.println(max);

    }

    public int largestRectangleArea1(int[] heights)
    {
        int n = heights.length;
        int[] left = new int[n];
        int[] right = new int[n];

        Stack<Integer> mono_stack = new Stack<Integer>();
        for (int i = 0; i < n; ++i)
        {
            while (!mono_stack.isEmpty() && heights[mono_stack.peek()] >= heights[i])
            {
                mono_stack.pop();
            }
            left[i] = (mono_stack.isEmpty() ? -1 : mono_stack.peek());
            mono_stack.push(i);
        }

        mono_stack.clear();
        for (int i = n - 1; i >= 0; --i)
        {
            while (!mono_stack.isEmpty() && heights[mono_stack.peek()] >= heights[i])
            {
                mono_stack.pop();
            }
            right[i] = (mono_stack.isEmpty() ? n : mono_stack.peek());
            mono_stack.push(i);
        }

        int ans = 0;
        for (int i = 0; i < n; ++i)
        {
            ans = Math.max(ans, (right[i] - left[i] - 1) * heights[i]);
        }
        return ans;
    }


}
//        String widthStr=null;
//        String heightStr=null;
//        int n=0;
//        for (int i = 0; i < line.length(); i++)
//        {
//            if (line.charAt(i)==']')
//            {
//                widthStr=line.substring(1,i);
//                n=i;
//                break;
//            }
//
//        }
//        heightStr=line.substring(n+3,line.length()-1);
//
//        String[] widthArr = widthStr.split(",");
//        String[] heightArr = heightStr.split(",");
//        int[] width=new int[widthArr.length];
//        int[] height=new int[heightArr.length];
//
//        for (int i = 0; i < widthArr.length; i++)
//        {
//            width[i]=Integer.valueOf(widthArr[i]);
//            height[i]=Integer.valueOf(heightArr[i]);
//
//        }
//[1,1,3,1],[5,2,4,5]



